package com.wuhao.shootclient.ui.widget;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;

import androidx.annotation.DrawableRes;
import androidx.annotation.Nullable;

import com.wuhao.shootclient.R;
import com.wuhao.shootclient.util.NotNullHelper;

import java.util.ArrayList;
import java.util.List;

public class CusTargetImg extends View {
    final float IMG_WIDTH = 1039, IMG_HEIGHT = 1069;

    private String TAG = "自定义模拟标靶类";

    //背景Bitmap
    private Bitmap backgroundBitmap = null;

    //画笔
    private Paint paint = null;

    //需要绘制点位的X坐标列表
    private List<Float> circleCentersX = new ArrayList<>();

    //需要绘制点位的Y坐标列表
    private List<Float> circleCentersY = new ArrayList<>();

    //需要绘制圆形的半径;
    private float circleRadius = 20F;

    //画布的宽高，用以跟视频图进行对比
    float canvasWidth = 0F;
    float canvasHeight = 0F;

    public CusTargetImg(Context context) {
        super(context);
        initFirst();
    }

    public CusTargetImg(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        initFirst();
    }

    public CusTargetImg(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        initFirst();
    }

    public CusTargetImg(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        initFirst();
    }

    /**
     * 初始化画笔、颜色
     */
    private void initFirst() {
        paint = new Paint();
        paint.setColor(Color.RED);
        paint.setStyle(Paint.Style.FILL);
        backgroundBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.bg_canvas);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        canvasWidth = w;
        canvasHeight = h;
    }


    /**
     * 绘制界面
     */
    @SuppressLint("DrawAllocation")
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (backgroundBitmap != null) {
            //获取画布的宽高
            canvasWidth = getWidth();
            canvasHeight = getHeight();
            // 这里需要添加计算逻辑来确定图片的缩放比例和绘制位置
            // 示例中没有包含这些逻辑，因为它们取决于你的具体需求
            // 假设你已经有了正确的缩放比例（scaleX, scaleY）和偏移量（translateX, translateY）
            // canvas.drawBitmap(backgroundBitmap, null, new RectF(translateX, translateY, translateX + backgroundBitmap.getWidth() * scaleX, translateY + backgroundBitmap.getHeight() * scaleY), null);

            //计算背景图与画布的宽高比
            double scaleWidth = (double) getWidth() / backgroundBitmap.getWidth();
            double scaleHeight = (double) getHeight() / backgroundBitmap.getHeight();
            //找到宽高比中最小的那个，避免拉伸
            float scale = (float) Math.min(scaleWidth, scaleHeight);
            //获取绘制出来之后bitmap的宽高数据
            float btMapWidth = backgroundBitmap.getWidth() * scale;
            float btMapHeight = backgroundBitmap.getHeight() * scale;
            //获取跟画布直接的偏移，用来居中使用
            float translateX = getWidth() - btMapWidth;
            float translateY = getHeight() - btMapHeight;
            //设置在画布上的矩形区域
            RectF rectF = new RectF(
                    translateX / 2,
                    translateY / 2,
                    translateX / 2 + btMapWidth,
                    translateY / 2 + btMapHeight
            );
            //先给绘制一个填满整个画布的灰色背景，用来和模拟靶图进行区分
            // 灰色可以有很多种，这里以一个中灰色为例
            paint.setColor(Color.parseColor("#808080"));
            //绘制灰色背景
            canvas.drawRect(new RectF(0F, 0F, getWidth(), getHeight()), paint);
            //绘制模拟靶图
            canvas.drawBitmap(
                    backgroundBitmap, //bitmap图
                    null, //需要绘制Bitmap图的区域，null的话表示全部区域
                    rectF, //绘制在画布上的区域
                    paint
            );//画笔
            //判断需要绘制的点不能为空
            if (NotNullHelper.notEmpty(circleCentersX) && NotNullHelper.notEmpty(circleCentersY)) {
                //设置画笔
                paint.setColor(Color.RED);// 设置Paint的颜色为红色
                paint.setStyle(Paint.Style.STROKE);// 设置Paint的样式为STROKE，这样只会绘制边框而不是填充内部
                paint.setStrokeWidth(4f);//设置边框的宽度（这将决定圆环的厚度）注意：边框宽度是实际绘制时笔触的粗细，它会影响圆环的视觉效果
                paint.setAntiAlias(true);//设置抗锯齿，使圆环边缘更平滑
                float pointScale = IMG_WIDTH / btMapWidth;
                //循环所有需要绘制的点
                for (int i = 0; i < circleCentersX.size(); i++) {
                    if (i == circleCentersX.size() - 1) {
                        //绘制圆心
                        paint.setColor(Color.GREEN);
                        paint.setStyle(Paint.Style.FILL);
                        canvas.drawCircle(
                                translateX / 2 + circleCentersX.get(i) * pointScale, //圆心的X坐标点
                                translateY / 2 + circleCentersY.get(i) * pointScale, //圆心的Y坐标点
                                circleRadius,//半径
                                paint
                        );
                        paint.setColor(Color.RED);// 设置Paint的颜色为红色
                        paint.setStyle(Paint.Style.STROKE);// 设置Paint的样式为STROKE，这样只会绘制边框而不是填充内部
                    } else {
                        //绘制圆环
                        canvas.drawCircle(
                                translateX / 2 + circleCentersX.get(i) * pointScale, //圆心的X坐标点
                                translateY / 2 + circleCentersY.get(i) * pointScale, //圆心的Y坐标点
                                circleRadius,//半径
                                paint
                        );
                    }
                }
            }
        }
    }


    // 确保在适当的时候释放Bitmap资源
    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        if (backgroundBitmap != null && !backgroundBitmap.isRecycled()) {
            backgroundBitmap.recycle();
            backgroundBitmap = null;
        }
    }


    /**
     * 设定需要绘制的圆形的集合
     *
     * @param centersX X坐标集合
     * @param centersY Y坐标集合
     */
    public void setCircleCenters(List<Float> centersX, List<Float> centersY) {
        if (NotNullHelper.notEmpty(centersX) && NotNullHelper.notEmpty(centersY)) {
            circleCentersX.clear();
            circleCentersX.addAll(centersX);
            circleCentersY.clear();
            circleCentersY.addAll(centersY);
            invalidate();
        } else {
            Log.i(TAG, "传入的参数为空！");
        }
    }

    /**
     * 设置新的模拟靶背景图
     *
     * @param newBg 新的模拟靶背景图
     */
    public void setBackground(@DrawableRes int newBg) {
        backgroundBitmap = BitmapFactory.decodeResource(getResources(), newBg);
    }

    /**
     * 插入一条新的数据
     *
     * @param xPoint X坐标点
     * @param yPoint Y坐标点
     */
    public void insertOnePoint(Float xPoint, Float yPoint) {
        //在原有的数据中新增数据
        circleCentersX.add(xPoint);
        circleCentersY.add(yPoint);
        invalidate();
    }

    /**
     * 插入一组新的数据，将新的数据拼接在旧的数据后面
     *
     * @param xPoint X坐标点集合
     * @param yPoint Y坐标点集合
     */
    public void insertListPoint(List<Float> xPoint, List<Float> yPoint) {
        //在原有的数据中新增数据
        circleCentersX.addAll(xPoint);
        circleCentersY.addAll(yPoint);
        invalidate();
    }

    /**
     * 插入一组新的数据，将新的数据拼接在旧的数据后面
     *
     * @param xPoint X坐标点集合
     * @param yPoint Y坐标点集合
     */
    public void insertListPointNoAppend(List<Float> xPoint, List<Float> yPoint) {
        //在原有的数据中新增数据
        if (NotNullHelper.notEmpty(xPoint) && NotNullHelper.notEmpty(yPoint)) {
            circleCentersX.clear();
            circleCentersY.clear();
            circleCentersX.addAll(xPoint);
            circleCentersY.addAll(yPoint);
            invalidate();
        } else {
            Log.i(TAG, "当前没用点！");
        }
    }

    /**
     * 插入一组新的数据，将新的数据拼接在旧的数据后面
     *
     * @param updateBean X坐标点集合
     */
    public void insertUpdateBeanListPoint(UpdateBean updateBean) {
        if (NotNullHelper.notEmpty(circleCentersX) && NotNullHelper.notEmpty(circleCentersY)) {
            circleCentersX.clear();
            circleCentersY.clear();
            //在原有的数据中新增数据
            circleCentersX.addAll(updateBean.newXList);
            circleCentersY.addAll(updateBean.newXList);
            invalidate();
        } else {
            Log.i(TAG, "当前没用点！");
        }

    }

    /**
     * 清除所有点位
     */
    public void clearAllPoint() {
        if (NotNullHelper.notEmpty(circleCentersX) && NotNullHelper.notEmpty(circleCentersY)) {
            circleCentersX.clear();
            circleCentersY.clear();
            invalidate();
        } else {
            Log.i(TAG, "当前没用点！");
        }
    }

    public static class UpdateBean {
        //需要绘制点位的X坐标列表
        private List<Float> newXList = new ArrayList<>();
        //需要绘制点位的Y坐标列表
        private List<Float> newYList = new ArrayList<>();

        public UpdateBean(List<Float> newXList, List<Float> newYList) {
            this.newXList = newXList;
            this.newYList = newYList;
        }

        public List<Float> getNewXList() {
            return newXList;
        }

        public void setNewXList(List<Float> newXList) {
            this.newXList = newXList;
        }

        public List<Float> getNewYList() {
            return newYList;
        }

        public void setNewYList(List<Float> newYList) {
            this.newYList = newYList;
        }
    }
}
